home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d1 / bastips2.arc / STRVARS.TXT < prev   
Text File  |  1988-11-29  |  5KB  |  98 lines
  1.                          BASIC String Variables
  2.                (BYTE Magazine June 1985 Review Feedback)
  3.  
  4.      In any BASIC program it is possible to substitute a variable for a 
  5. string when it is not acceptable to the BASIC interpreters by leaving 
  6. blank spaces within the quotation marks that need the string, then 
  7. POKEing the string variable into the blanks character-by-character. 
  8. This works in any variation of any BASIC.
  9.      Most BASICs store keywords like OPEN, CLOSE, and GOTO as a 1-byte 
  10. token instead of correctly spelling the keyword.  This saves memory and 
  11. speeds searches for the correct routine to execute the command.  Some 
  12. versions of Microsoft BASIC use 153 as the token for OPEN.  The numbers 
  13. are usually above the highest printing ASCII codes (above 127) and 
  14. appear as graphics characters if you PEEK into the spot where the OPEN 
  15. token is stored.  If you loop through the computer's memory looking for 
  16. the OPEN command's token, you will locate the line of code that needs to 
  17. have the variable POKEd into the blanks between the quotation marks.  In 
  18. other words, you tell the computer to look through its memory starting 
  19. at the beginning of your program and find the line you need by searching 
  20. for OPEN.
  21.      You need to look at a memory map of your computer to find out the 
  22. address of the pointer that stores the address of the start of a BASIC 
  23. program.  The BST variable in line 200 of program 1 below is the address 
  24. that points to the start of the BASIC program area, sometimes referred 
  25. to as the BASIC buffer.  BEND is the variable found by PEEKing the 
  26. address of the start of the variables found in the pointer table.  Some 
  27. BASICs do not use a pointer to the end of your program; the end is 
  28. simply defined by a series of zeros when the program is entered.  You 
  29. should find both BST and BEND before running the subroutine by PEEKing 
  30. at the table of pointers and using the appropriate math.  You can find 
  31. them during program execution if you know the pointers for sure.
  32.      If you do not have a memory map and do not know what the token for 
  33. OPEN is, loop through the entire memory looking for a dummy line of 
  34. text, then branch out of the loop and get the address where the dummy 
  35. text was found (see program 2).
  36.      Progarm 1 POKEs FL$ into the filename after OPEN in line 110.  This 
  37. whole section is treated as a subroutine and is exited after the CLOSE 
  38. statement in line 130.  More string manipulation could be done to check 
  39. for a filename extension in FL$ instead of truncating FL$ when it is too 
  40. long and forcing the extension to DAT. BST, BEND, and FL$ must be 
  41. initialized before entering the subroutine.
  42.      After you run this program, get a listing and see how line 110 is 
  43. changed with FL$ in place of the blank spaces.
  44.      Program 2 should be run independently of the first program and run 
  45. several times using different characters in the remark statement in line 
  46. 10, and in lines 50 and 110 to be certain there isn't a felonious group 
  47. of Xs.  After finding the start of BASIC, you find the end by adding the 
  48. available memory in an empty buffer to the start address.
  49. - - - - -
  50. Program 1: POKEs FL$ into a filename
  51.  
  52. 105 GOSUB 200
  53. 110 OPEN "0",#1,"      /DAT"
  54. 120 PRINT #1,"SOME DATA"
  55. 130 CLOSE #1
  56. 140 RETURN
  57. 200 FOR A=BST TO BEND
  58. 205 'BST & BEND are start and end of BASIC buffer
  59. 210 IF PEEK(A)=(TOKEN FOR "OPEN") THEN 250
  60. 215 'Line 210 branches at the OPEN token
  61. 220 NEXT A:RETURN
  62. 250 IF PEEK(A+1)=34 THEN 280
  63. 260 'Line 250 checks character after OPEN
  64. 265 'and branches at CHR$(34) or " sign
  65. 270 NEXT A:RETURN
  66. 280 IF PEEK(A+2)=ASC("0") THEN 310
  67. 290 'Line 280 is second redundancy check
  68. 300 NEXT A:RETURN
  69. 310 FL=8:IF LEN(FL$)<>8 THEN GOSUB 500
  70. 320 'Line 310 branches to padding routine to bring
  71. 325 'length of FL$ to 8 characters
  72. 330 C=0:FOR B=A+9 TO A+9+FL
  73. 340 C=C+1:POKE B,ASC(MID$(FL$,C,1))
  74. 350 NEXT B:NEXT A:RETURN
  75. 500 IF LEN(FL$)>8 THEN 550
  76. 510 FOR PAD=LEN(FL$) TO 7
  77. 520 FL$=FL$+" "
  78. 530 NEXT PAD:RETURN
  79. 550 FL$=LEFT$(FL$,8):RETURN
  80. - - - - -
  81. Program 2: Finds the start address of the BASIC buffer and the token for 
  82.            OPEN
  83. 10 'XXXXXXXXXXXXXXXX
  84. 20 OPEN "0",#1,"DUMMY"
  85. 30 CLOSE #1
  86. 40 FOR X=0 TO 65536
  87. 50 IF PEEK(X)=ASC("X") THEN 100
  88. 60 NEXT X:END
  89. 100 FOR Y=X TO X+16
  90. 110 IF PEK(Y)<>ASC("X") THEN 60
  91. 120 NEXT Y:PRINT "START ADDRESS OF BASIC IS";X-8
  92. 130 FOR Y=X TO X+25
  93. 140 IF PEEK(Y)=34 THEN 200
  94. 150 NEXT Y
  95. 200 PRINT"TOKEN FOR OPEN COMMAND IS";PEEK(Y-1)
  96.  
  97. -----------------------------------------------------------------
  98.